package net.jgrm.common.util;

import cn.hutool.core.util.DesensitizedUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.AES;
import cn.hutool.crypto.symmetric.SymmetricAlgorithm;

/**
 * 数据脱敏和加密工具类
 * 提供手机号、身份证、银行卡号等敏感信息的脱敏和加密处理
 *
 * @author service-common
 * @since 1.0-SNAPSHOT
 */
public class DataMaskingUtil {

    /**
     * 默认AES加密密钥（实际项目中应该从配置文件读取）
     */
    private static final String DEFAULT_AES_KEY = "MySecretKey12345"; // 16位密钥

    /**
     * 手机号处理工具类
     */
    public static class MobileUtil {

        /**
         * 手机号脱敏显示
         * 显示前3位和后4位，中间用*号替代
         * 例：138****5678
         */
        public static String mask(String mobile) {
            if (StrUtil.isBlank(mobile)) {
                return mobile;
            }
            return DesensitizedUtil.mobilePhone(mobile);
        }

        /**
         * 手机号AES加密
         */
        public static String encrypt(String mobile) {
            return encrypt(mobile, DEFAULT_AES_KEY);
        }

        /**
         * 手机号AES加密（自定义密钥）
         */
        public static String encrypt(String mobile, String key) {
            if (StrUtil.isBlank(mobile)) {
                return mobile;
            }
            AES aes = SecureUtil.aes(key.getBytes());
            return aes.encryptHex(mobile);
        }

        /**
         * 手机号AES解密
         */
        public static String decrypt(String encryptedMobile) {
            return decrypt(encryptedMobile, DEFAULT_AES_KEY);
        }

        /**
         * 手机号AES解密（自定义密钥）
         */
        public static String decrypt(String encryptedMobile, String key) {
            if (StrUtil.isBlank(encryptedMobile)) {
                return encryptedMobile;
            }
            try {
                AES aes = SecureUtil.aes(key.getBytes());
                return aes.decryptStr(encryptedMobile);
            } catch (Exception e) {
                throw new RuntimeException("手机号解密失败", e);
            }
        }

        /**
         * 手机号MD5不可逆加密（用于比对验证）
         */
        public static String hash(String mobile) {
            if (StrUtil.isBlank(mobile)) {
                return mobile;
            }
            return SecureUtil.md5(mobile);
        }
    }

    /**
     * 身份证处理工具类
     */
    public static class IdCardUtil {

        /**
         * 身份证脱敏显示
         * 显示前6位和后4位，中间用*号替代
         * 例：110101********1234
         */
        public static String mask(String idCard) {
            if (StrUtil.isBlank(idCard)) {
                return idCard;
            }
            return DesensitizedUtil.idCardNum(idCard, 6, 4);
        }

        /**
         * 身份证AES加密
         */
        public static String encrypt(String idCard) {
            return encrypt(idCard, DEFAULT_AES_KEY);
        }

        /**
         * 身份证AES加密（自定义密钥）
         */
        public static String encrypt(String idCard, String key) {
            if (StrUtil.isBlank(idCard)) {
                return idCard;
            }
            AES aes = SecureUtil.aes(key.getBytes());
            return aes.encryptHex(idCard);
        }

        /**
         * 身份证AES解密
         */
        public static String decrypt(String encryptedIdCard) {
            return decrypt(encryptedIdCard, DEFAULT_AES_KEY);
        }

        /**
         * 身份证AES解密（自定义密钥）
         */
        public static String decrypt(String encryptedIdCard, String key) {
            if (StrUtil.isBlank(encryptedIdCard)) {
                return encryptedIdCard;
            }
            try {
                AES aes = SecureUtil.aes(key.getBytes());
                return aes.decryptStr(encryptedIdCard);
            } catch (Exception e) {
                throw new RuntimeException("身份证解密失败", e);
            }
        }

        /**
         * 身份证MD5不可逆加密（用于比对验证）
         */
        public static String hash(String idCard) {
            if (StrUtil.isBlank(idCard)) {
                return idCard;
            }
            return SecureUtil.md5(idCard);
        }

        /**
         * 验证身份证格式是否正确
         */
        public static boolean validate(String idCard) {
            return cn.hutool.core.util.IdcardUtil.isValidCard(idCard);
        }

        /**
         * 从身份证中提取生日
         */
        public static String getBirthday(String idCard) {
            if (!validate(idCard)) {
                throw new IllegalArgumentException("身份证格式不正确");
            }
            return cn.hutool.core.util.IdcardUtil.getBirth(idCard);
        }

        /**
         * 从身份证中提取年龄
         */
        public static int getAge(String idCard) {
            if (!validate(idCard)) {
                throw new IllegalArgumentException("身份证格式不正确");
            }
            return cn.hutool.core.util.IdcardUtil.getAgeByIdCard(idCard);
        }

        /**
         * 从身份证中提取性别
         */
        public static String getGender(String idCard) {
            if (!validate(idCard)) {
                throw new IllegalArgumentException("身份证格式不正确");
            }
            return cn.hutool.core.util.IdcardUtil.getGenderByIdCard(idCard) == 1 ? "男" : "女";
        }
    }

    /**
     * 银行卡处理工具类
     */
    public static class BankCardUtil {

        /**
         * 银行卡号脱敏显示
         * 显示前4位和后4位，中间用*号替代
         * 例：6225********1234
         */
        public static String mask(String bankCard) {
            if (StrUtil.isBlank(bankCard)) {
                return bankCard;
            }
            return DesensitizedUtil.bankCard(bankCard);
        }

        /**
         * 银行卡号AES加密
         */
        public static String encrypt(String bankCard) {
            return encrypt(bankCard, DEFAULT_AES_KEY);
        }

        /**
         * 银行卡号AES加密（自定义密钥）
         */
        public static String encrypt(String bankCard, String key) {
            if (StrUtil.isBlank(bankCard)) {
                return bankCard;
            }
            AES aes = SecureUtil.aes(key.getBytes());
            return aes.encryptHex(bankCard);
        }

        /**
         * 银行卡号AES解密
         */
        public static String decrypt(String encryptedBankCard) {
            return decrypt(encryptedBankCard, DEFAULT_AES_KEY);
        }

        /**
         * 银行卡号AES解密（自定义密钥）
         */
        public static String decrypt(String encryptedBankCard, String key) {
            if (StrUtil.isBlank(encryptedBankCard)) {
                return encryptedBankCard;
            }
            try {
                AES aes = SecureUtil.aes(key.getBytes());
                return aes.decryptStr(encryptedBankCard);
            } catch (Exception e) {
                throw new RuntimeException("银行卡号解密失败", e);
            }
        }

        /**
         * 银行卡号MD5不可逆加密（用于比对验证）
         */
        public static String hash(String bankCard) {
            if (StrUtil.isBlank(bankCard)) {
                return bankCard;
            }
            return SecureUtil.md5(bankCard);
        }
    }

    /**
     * 通用脱敏工具类
     */
    public static class CommonUtil {

        /**
         * 姓名脱敏
         * 例：张三 -> 张*，李四五 -> 李**
         */
        public static String maskName(String name) {
            if (StrUtil.isBlank(name)) {
                return name;
            }
            return DesensitizedUtil.chineseName(name);
        }

        /**
         * 地址脱敏
         * 保留前6位，后面用*替代
         */
        public static String maskAddress(String address) {
            if (StrUtil.isBlank(address)) {
                return address;
            }
            return DesensitizedUtil.address(address, 6);
        }

        /**
         * 邮箱脱敏
         * 例：example@qq.com -> e****@qq.com
         */
        public static String maskEmail(String email) {
            if (StrUtil.isBlank(email)) {
                return email;
            }
            return DesensitizedUtil.email(email);
        }

        /**
         * 密码脱敏
         * 全部用*替代
         */
        public static String maskPassword(String password) {
            if (StrUtil.isBlank(password)) {
                return password;
            }
            return DesensitizedUtil.password(password);
        }

        /**
         * 自定义脱敏
         *
         * @param str        原始字符串
         * @param prefixKeep 前面保留位数
         * @param suffixKeep 后面保留位数
         * @param mask       脱敏字符
         * @return 脱敏后的字符串
         */
        public static String customMask(String str, int prefixKeep, int suffixKeep, char mask) {
            if (StrUtil.isBlank(str)) {
                return str;
            }
            int length = str.length();
            if (prefixKeep + suffixKeep >= length) {
                return str;
            }

            StringBuilder result = new StringBuilder();
            // 保留前面的字符
            result.append(str, 0, prefixKeep);
            // 中间用指定字符替代
            for (int i = prefixKeep; i < length - suffixKeep; i++) {
                result.append(mask);
            }
            // 保留后面的字符
            result.append(str.substring(length - suffixKeep));

            return result.toString();
        }
    }

    /**
     * 高级加密工具类（使用更强的加密算法）
     */
    public static class AdvancedCryptoUtil {

        /**
         * 生成AES密钥
         */
        public static String generateAESKey() {
            return SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue()).toString();
        }

        /**
         * 使用SHA256加盐哈希（适用于密码存储）
         */
        public static String sha256WithSalt(String data, String salt) {
            if (StrUtil.isBlank(data)) {
                return data;
            }
            return SecureUtil.sha256(data + salt);
        }

        /**
         * 生成随机盐值
         */
        public static String generateSalt() {
            return cn.hutool.core.util.RandomUtil.randomString(16);
        }
    }
}